home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / meadows.c < prev    next >
C/C++ Source or Header  |  2000-05-20  |  7KB  |  233 lines
  1. /***************************************************************************
  2.     meadows.c
  3.     Video handler
  4.     Dead Eye, Gypsy Juggler
  5.  
  6.     J. Buchmueller, June '98
  7. ****************************************************************************/
  8.  
  9. #include "vidhrdw/generic.h"
  10. #include "artwork.h"
  11.  
  12. #define USE_OVERLAY
  13.  
  14. /* some constants to make life easier */
  15. #define SCR_HORZ        32
  16. #define SCR_VERT        30
  17. #define CHR_HORZ        8
  18. #define CHR_VERT        8
  19. #define SPR_COUNT       4
  20. #define SPR_HORZ        16
  21. #define SPR_VERT        16
  22. #define SPR_ADJUST_X    -18
  23. #define SPR_ADJUST_Y    -14
  24.  
  25. static  int sprite_dirty[SPR_COUNT];    /* dirty flags */
  26. static  int sprite_horz[SPR_COUNT];     /* x position */
  27. static  int sprite_vert[SPR_COUNT];     /* y position */
  28. static  int sprite_index[SPR_COUNT];    /* index 0x00..0x0f, prom 0x10, flip horz 0x20 */
  29.  
  30. static struct artwork_element deadeye_artwork[] = {
  31.     {{0,             SCR_HORZ*8-1,     0,      4*8-1},          32,192, 64, OVERLAY_DEFAULT_OPACITY},
  32.     {{0,             SCR_HORZ*8-1,     4*8,     8*8-1},          64, 64,192, OVERLAY_DEFAULT_OPACITY},
  33.     {{0,             SCR_HORZ*8-1,     8*8,     11*8-1},         192,160, 32, OVERLAY_DEFAULT_OPACITY},
  34.     {{0,             1*8-1,          11*8,     26*8-1},         192,160, 32, OVERLAY_DEFAULT_OPACITY},
  35.     {{SCR_HORZ*8-8,  SCR_HORZ*8-1,     11*8,     26*8-1},         192,160, 32, OVERLAY_DEFAULT_OPACITY},
  36.     {{0,             SCR_HORZ*8-1,     26*8,     SCR_VERT*8-1},   64, 64,192, OVERLAY_DEFAULT_OPACITY},
  37.     {{-1,-1,-1,-1},0,0,0,0},
  38. };
  39.  
  40. static struct artwork_element gypsyjug_artwork[] = {
  41.     {{0,             SCR_HORZ*8-1,     0,      4*8-1},          32,192, 64, OVERLAY_DEFAULT_OPACITY},
  42.     {{0,             SCR_HORZ*8-1,     4*8,     8*8-1},          64, 64,192, OVERLAY_DEFAULT_OPACITY},
  43.     {{0,             SCR_HORZ*8-1,     4*8,     5*8-1},          32,192, 64, OVERLAY_DEFAULT_OPACITY},
  44.     {{0,             SCR_HORZ*8-1,     5*8,     8*8-1},          64, 64,192, OVERLAY_DEFAULT_OPACITY},
  45.     {{0,             SCR_HORZ*8-1,     8*8,     11*8-1},         192,160, 32, OVERLAY_DEFAULT_OPACITY},
  46.     {{0,             1*8-1,          11*8,     26*8-1},         192,160, 32, OVERLAY_DEFAULT_OPACITY},
  47.     {{SCR_HORZ*8-8,  SCR_HORZ*8-1,     11*8,     26*8-1},         192,160, 32, OVERLAY_DEFAULT_OPACITY},
  48.     {{0,             SCR_HORZ*8-1,     26*8,     SCR_VERT*8-1},  192,160, 32, OVERLAY_DEFAULT_OPACITY},
  49.     {{-1,-1,-1,-1},0,0,0,0},
  50. };
  51.  
  52. /*************************************************************/
  53. /* video handler start                                       */
  54. /*************************************************************/
  55. int deadeye_vh_start(void)
  56. {
  57.     if( generic_vh_start() ) return 1;
  58.  
  59.     overlay_create(deadeye_artwork, 2, Machine->drv->total_colors - 2);
  60.  
  61.     return 0;
  62. }
  63.  
  64. int gypsyjug_vh_start(void)
  65. {
  66.     if( generic_vh_start() ) return 1;
  67.  
  68.     overlay_create(gypsyjug_artwork, 2, Machine->drv->total_colors - 2);
  69.  
  70.     return 0;
  71. }
  72.  
  73.  
  74. /*************************************************************/
  75. /* draw dirty sprites                                        */
  76. /*************************************************************/
  77. static void meadows_draw_sprites(struct osd_bitmap *bitmap)
  78. {
  79.     int     i;
  80.     for( i = 0; i < SPR_COUNT; i++ ) {
  81.         int x, y, n, p, f;
  82.         if (!sprite_dirty[i])                /* sprite not dirty? */
  83.             continue;
  84.         sprite_dirty[i] = 0;
  85.         x = sprite_horz[i];
  86.         y = sprite_vert[i];
  87.         n = sprite_index[i] & 0x0f;         /* bit #0 .. #3 select sprite */
  88. //        p = (sprite_index[i] >> 4) & 1;     /* bit #4 selects prom ??? */
  89.         p = i;                                /* that fixes it for now :-/ */
  90.         f = sprite_index[i] >> 5;            /* bit #5 flip vertical flag */
  91.         drawgfx(bitmap, Machine->gfx[p + 1],
  92.             n, 1, f, 0, x, y,
  93.             &Machine->drv->visible_area,
  94.             TRANSPARENCY_PEN,0);
  95.     }
  96. }
  97.  
  98.  
  99. /*************************************************************/
  100. /* mark character cell dirty                                 */
  101. /*************************************************************/
  102. static void meadows_char_dirty(int x, int y)
  103. {
  104. int     i;
  105.     /* scan sprites */
  106.     for (i = 0; i < 4; i++)
  107.     {
  108.         /* check if sprite rectangle intersects with text rectangle */
  109.         if ((x + 7 >= sprite_horz[i] && x <= sprite_horz[i] + 15) ||
  110.             (y + 7 >= sprite_vert[i] && y <= sprite_vert[i] + 15))
  111.                 sprite_dirty[i] = 1;
  112.     }
  113. }
  114.  
  115. /*************************************************************/
  116. /* Screen refresh                                             */
  117. /*************************************************************/
  118. void meadows_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  119. {
  120.     int     i;
  121.  
  122.     if (palette_recalc() || full_refresh)
  123.     {
  124.         memset(dirtybuffer,1,SCR_VERT * SCR_HORZ);
  125.     }
  126.  
  127.     /* the first two rows are invisible */
  128.     for (i = 0; i < SCR_VERT * SCR_HORZ; i++)
  129.     {
  130.         if (dirtybuffer[i])
  131.         {
  132.             int x, y;
  133.             dirtybuffer[i] = 0;
  134.  
  135.             x = (i % SCR_HORZ) * CHR_HORZ;
  136.             y = (i / SCR_HORZ) * CHR_VERT;
  137.  
  138.             drawgfx(bitmap, Machine->gfx[0],
  139.                 videoram[i] & 0x7f, 1, 0,0, x, y,
  140.                 &Machine->drv->visible_area,
  141.                 TRANSPARENCY_NONE,0);
  142.             meadows_char_dirty(x,y);
  143.         }
  144.     }
  145.     /* now draw the sprites */
  146.     meadows_draw_sprites(bitmap);
  147. }
  148.  
  149. /*************************************************************/
  150. /*                                                           */
  151. /* Video RAM write                                           */
  152. /*                                                           */
  153. /*************************************************************/
  154. WRITE_HANDLER( meadows_videoram_w )
  155. {
  156.     if (offset >= videoram_size)
  157.         return;
  158.     if (videoram[offset] == data)
  159.         return;
  160.     videoram[offset] = data;
  161.     dirtybuffer[offset] = 1;
  162. }
  163.  
  164.  
  165. /*************************************************************/
  166. /* Mark sprite n covered area dirty                          */
  167. /*************************************************************/
  168. static  void    dirty_sprite(int n)
  169. {
  170. int     x, y;
  171.  
  172.     sprite_dirty[n] = 1;
  173.  
  174.     for (y = sprite_vert[n] / CHR_VERT;
  175.          y < (sprite_vert[n] + CHR_VERT - 1) / CHR_VERT + SPR_VERT / CHR_VERT ;
  176.          y++)
  177.     {
  178.         for (x = sprite_horz[n] / CHR_HORZ;
  179.              x < (sprite_horz[n] + CHR_HORZ - 1) / CHR_HORZ + SPR_HORZ / CHR_HORZ;
  180.              x++)
  181.         {
  182.             if (y >= 0 && y < SCR_VERT && x >= 0 && x < SCR_HORZ)
  183.                 dirtybuffer[y * SCR_HORZ + x] = 1;
  184.         }
  185.     }
  186.  
  187. //    logerror("sprite_dirty(%d) %d %d\n", n, sprite_horz[n], sprite_vert[n]);
  188. }
  189.  
  190. /*************************************************************/
  191. /* write to the sprite registers                             */
  192. /*************************************************************/
  193. WRITE_HANDLER( meadows_sprite_w )
  194. {
  195. int     n = offset % SPR_COUNT;
  196.     switch (offset)
  197.     {
  198.         case 0: /* sprite 0 horz */
  199.         case 1: /* sprite 1 horz */
  200.         case 2: /* sprite 2 horz */
  201.         case 3: /* sprite 3 horz */
  202.             if (sprite_horz[n] != data)
  203.             {
  204.                 dirty_sprite(n);
  205.                 sprite_horz[n] = data + SPR_ADJUST_X;
  206.             }
  207.             break;
  208.         case 4: /* sprite 0 vert */
  209.         case 5: /* sprite 1 vert */
  210.         case 6: /* sprite 2 vert */
  211.         case 7: /* sprite 3 vert */
  212.             if (sprite_horz[n] != data)
  213.             {
  214.                 dirty_sprite(n);
  215.                 sprite_vert[n] = data + SPR_ADJUST_Y;
  216.             }
  217.             break;
  218.         case  8: /* prom 1 select + reverse shifter */
  219.         case  9: /* prom 2 select + reverse shifter */
  220.         case 10: /* ??? prom 3 select + reverse shifter */
  221.         case 11: /* ??? prom 4 select + reverse shifter */
  222.             if (sprite_index[n] != data)
  223.             {
  224.                 dirty_sprite(n);
  225.                 sprite_index[n] = data;
  226.             }
  227.             break;
  228.     }
  229. }
  230.  
  231.  
  232.  
  233.